#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
联系人数据访问对象 (DAO)
严格遵循DAO层职责：仅负责数据库CRUD操作，不包含任何业务逻辑
"""

from typing import List, Dict, Optional
from models.user import User
from models.base import db
import uuid
from datetime import datetime

from sqlalchemy import or_

class ContactDAO:
    """联系人数据访问对象
    
    职责：
    - 执行用户表的CRUD操作
    - 批量插入/更新联系人数据
    - 查询联系人数据
    - 不包含任何业务逻辑或数据验证
    """
    
    def __init__(self):
        """初始化DAO"""
        pass
    
    def get_user_by_wechat_id(self, wechat_id: str, account: str) -> Optional[User]:
        """根据微信ID和账号查询用户
        
        Args:
            wechat_id: 微信ID
            account: 所属账号
            
        Returns:
            User对象或None
        """
        return User.query.filter(
            User.wechat_id == wechat_id,
            User.account == account
        ).first()
    
    def get_users_by_account(self, account: str) -> List[User]:
        """
        根据账号查询所有用户
        
        Args:
            account: 所属账号
            
        Returns:
            User对象列表
        """
        return User.query.filter(User.account == account).all()
        
    def get_users_by_account_paginated(self, account: str, page: int = 1, per_page: int = 20, user_type: int = 1) -> Dict:
        """
        根据账号分页查询用户
        
        Args:
            account: 所属账号
            page: 页码，从1开始
            per_page: 每页记录数
            user_type: 用户类型，1(好友), 2(群成员)
            
        Returns:
            Dict: 包含分页信息和用户列表的字典
            {
                'items': List[User],  # 当前页的用户列表
                'total': int,          # 总记录数
                'page': int,           # 当前页码
                'per_page': int,       # 每页记录数
                'pages': int           # 总页数
                'has_prev': bool,      # 是否有上一页
                'has_next': bool,      # 是否有下一页
                'prev_page': int,      # 上一页页码
                'next_page': int       # 下一页页码
            }
        """
        from settings.config import get_logger
        from utils.pagination import paginate_query
        
        logger = get_logger(__name__)
        
        try:
            # 构建查询
            query = User.query.filter(
                User.account == account,
                User.user_type == user_type
            )
            
            # 使用通用分页工具进行分页
            paginator = paginate_query(
                query=query,
                page=page,
                per_page=per_page,
                order_by='created_at desc'
            )

            logger.debug(f"分页查询的结果是：{paginator.to_dict()}")
            
            # 返回分页结果
            return paginator.to_dict()
            
        except Exception as e:
            logger.error(f"分页查询用户失败: {e}")
            import traceback
            logger.error(traceback.format_exc())
            raise
    
    def insert_user(self, user_data: Dict) -> str:
        """插入单个用户记录
        
        Args:
            user_data: 用户数据字典
            
        Returns:
            新插入用户的ID
        """
        from settings.config import logger
        
        try:
            # 确保user_type是整数类型
            user_type = user_data.get('user_type', 1)
            if not isinstance(user_type, int):
                logger.warning(f"user_type不是整数类型，当前值: {user_type}，类型: {type(user_type)}")
                try:
                    user_type = int(user_type)
                    logger.info(f"已将user_type转换为整数: {user_type}")
                except (ValueError, TypeError):
                    logger.warning(f"无法将user_type转换为整数，使用默认值1")
                    user_type = 1
            
            logger.info(f"创建新用户: {user_data.get('wechat_name')}，user_type={user_type}")
            
            user = User(
                id=str(uuid.uuid4()),
                account=user_data.get('account'),
                wechat_name=user_data.get('wechat_name'),
                wechat_id=user_data.get('wechat_id'),
                remark_name=user_data.get('remark_name'),
                user_type=user_type,  # 确保是整数类型
                avatar_url=user_data.get('avatar_url'),
                signature=user_data.get('signature'),
                is_friend=user_data.get('is_friend', True),
                auto_reply_enabled=user_data.get('auto_reply_enabled', False),
                custom_reply_message=user_data.get('custom_reply_message'),
                is_blocked=user_data.get('is_blocked', False),
                description=user_data.get('description'),
                # 以下字段在数据库中不存在，已移除
                # region=user_data.get('region'),
                # phone=user_data.get('phone'),
                # tags=user_data.get('tags'),
                # friend_permission=user_data.get('friend_permission'),
                # common_groups=user_data.get('common_groups'),
                # source=user_data.get('source'),
                created_at=datetime.now(),
                updated_at=datetime.now()
            )
            
            db.session.add(user)
            db.session.commit()
            logger.info(f"成功创建新用户: {user.wechat_name}，ID: {user.id}")
            return user.id
            
        except Exception as e:
            logger.error(f"创建用户失败: {e}")
            logger.error(f"用户数据: {user_data}")
            import traceback
            logger.error(traceback.format_exc())
            db.session.rollback()
            raise
    
    def update_user(self, user_id: str, user_data: Dict) -> bool:
        """更新用户记录
        
        Args:
            user_id: 用户ID
            user_data: 更新的用户数据
            
        Returns:
            是否更新成功
        """
        from settings.config import logger
        
        try:
            logger.info(f"更新用户: user_id={user_id}")
            
            user = User.query.filter(User.id == user_id).first()
            if not user:
                logger.warning(f"未找到要更新的用户: user_id={user_id}")
                return False
            
            logger.info(f"找到要更新的用户: {user.wechat_name}, wechat_id={user.wechat_id}")
            
            # 处理user_type字段，确保是整数类型
            if 'user_type' in user_data:
                user_type = user_data['user_type']
                if not isinstance(user_type, int):
                    logger.warning(f"user_type不是整数类型，当前值: {user_type}，类型: {type(user_type)}")
                    try:
                        user_data['user_type'] = int(user_type)
                        logger.info(f"已将user_type转换为整数: {user_data['user_type']}")
                    except (ValueError, TypeError):
                        logger.warning(f"无法将user_type转换为整数，使用默认值1")
                        user_data['user_type'] = 1
            
            # 更新字段
            updated_fields = []
            for key, value in user_data.items():
                if hasattr(user, key):
                    old_value = getattr(user, key)
                    if old_value != value:
                        setattr(user, key, value)
                        updated_fields.append(f"{key}: {old_value} -> {value}")
            
            if updated_fields:
                logger.info(f"更新的字段: {', '.join(updated_fields)}")
            else:
                logger.info("没有字段需要更新")
            
            user.updated_at = datetime.now()
            db.session.commit()
            logger.info(f"成功更新用户: {user.wechat_name}")
            return True
            
        except Exception as e:
            logger.error(f"更新用户失败: {e}")
            logger.error(f"用户数据: {user_data}")
            import traceback
            logger.error(traceback.format_exc())
            db.session.rollback()
            return False
    
    def update_user_by_wechat_id(self, wechat_id: str, account: str, user_data: Dict) -> bool:
        """根据微信ID更新用户记录
        
        Args:
            wechat_id: 微信ID
            account: 所属账号
            user_data: 更新的用户数据
            
        Returns:
            是否更新成功
        """
        from settings.config import logger
        
        try:
            logger.info(f"根据微信ID更新用户: wechat_id={wechat_id}, account={account}")
            
            user = User.query.filter(
                User.wechat_id == wechat_id,
                User.account == account
            ).first()
            
            if not user:
                logger.warning(f"未找到要更新的用户: wechat_id={wechat_id}, account={account}")
                return False
            
            logger.info(f"找到要更新的用户: {user.wechat_name}, ID={user.id}")
            
            # 处理user_type字段，确保是整数类型
            if 'user_type' in user_data:
                user_type = user_data['user_type']
                if not isinstance(user_type, int):
                    logger.warning(f"user_type不是整数类型，当前值: {user_type}，类型: {type(user_type)}")
                    try:
                        user_data['user_type'] = int(user_type)
                        logger.info(f"已将user_type转换为整数: {user_data['user_type']}")
                    except (ValueError, TypeError):
                        logger.warning(f"无法将user_type转换为整数，使用默认值1")
                        user_data['user_type'] = 1
            
            # 更新字段
            updated_fields = []
            for key, value in user_data.items():
                if hasattr(user, key):
                    old_value = getattr(user, key)
                    if old_value != value:
                        setattr(user, key, value)
                        updated_fields.append(f"{key}: {old_value} -> {value}")
            
            if updated_fields:
                logger.info(f"更新的字段: {', '.join(updated_fields)}")
            else:
                logger.info("没有字段需要更新")
            
            user.updated_at = datetime.now()
            db.session.commit()
            logger.info(f"成功更新用户: {user.wechat_name}")
            return True
            
        except Exception as e:
            logger.error(f"更新用户失败: {e}")
            logger.error(f"用户数据: {user_data}")
            import traceback
            logger.error(traceback.format_exc())
            db.session.rollback()
            return False
    
    def batch_insert_users(self, users_data: List[Dict]) -> List[str]:
        """批量插入用户记录
        
        Args:
            users_data: 用户数据列表
            
        Returns:
            新插入用户的ID列表
        """
        from settings.config import logger
        
        user_ids = []
        try:
            logger.info(f"开始批量插入用户，数量: {len(users_data)}")
            
            for user_data in users_data:
                # 处理user_type字段，确保是整数类型
                user_type = user_data.get('user_type', 1)
                if not isinstance(user_type, int):
                    logger.warning(f"user_type不是整数类型，当前值: {user_type}，类型: {type(user_type)}")
                    try:
                        user_type = int(user_type)
                        logger.info(f"已将user_type转换为整数: {user_type}")
                    except (ValueError, TypeError):
                        logger.warning(f"无法将user_type转换为整数，使用默认值1")
                        user_type = 1
                
                user_id = str(uuid.uuid4())
                logger.info(f"创建新用户: {user_data.get('wechat_name', '未知')}, wechat_id={user_data.get('wechat_id', '未知')}, user_type={user_type}")
                
                user = User(
                     id=user_id,
                     account=user_data.get('account'),
                     wechat_name=user_data.get('wechat_name'),
                     wechat_id=user_data.get('wechat_id'),
                     remark_name=user_data.get('remark_name'),
                     user_type=user_type,  # 确保是整数类型
                     avatar_url=user_data.get('avatar_url'),
                     signature=user_data.get('signature'),
                     is_friend=user_data.get('is_friend', True),
                     auto_reply_enabled=user_data.get('auto_reply_enabled', False),
                     custom_reply_message=user_data.get('custom_reply_message'),
                     is_blocked=user_data.get('is_blocked', False),
                     description=user_data.get('description'),
                     # 以下字段在数据库中不存在，已移除
                     # region=user_data.get('region'),
                     # phone=user_data.get('phone'),
                     # tags=user_data.get('tags'),
                     # friend_permission=user_data.get('friend_permission'),
                     # common_groups=user_data.get('common_groups'),
                     # source=user_data.get('source'),
                     created_at=datetime.now(),
                     updated_at=datetime.now()
                 )
                db.session.add(user)
                user_ids.append(user_id)
            
            db.session.commit()
            logger.info(f"批量插入用户成功，共插入{len(user_ids)}个用户")
            return user_ids
            
        except Exception as e:
            logger.error(f"批量插入用户失败: {e}")
            import traceback
            logger.error(traceback.format_exc())
            db.session.rollback()
            return []
    
    def delete_user(self, user_id: str) -> bool:
        """删除用户记录
        
        Args:
            user_id: 用户ID
            
        Returns:
            是否删除成功
        """
        user = User.query.filter(User.id == user_id).first()
        if not user:
            return False
        
        db.session.delete(user)
        db.session.commit()
        return True
    
    def delete_users_by_account(self, account: str) -> int:
        """删除指定账号的所有用户
        
        Args:
            account: 所属账号
            
        Returns:
            删除的记录数
        """
        deleted_count = User.query.filter(User.account == account).delete()
        db.session.commit()
        return deleted_count
    
    def count_users_by_account(self, account: str) -> int:
        """统计指定账号的用户数量
        
        Args:
            account: 所属账号
            
        Returns:
            用户数量
        """
        return User.query.filter(User.account == account).count()
    
    def save_or_update_contact(self, user_data: Dict) -> bool:
        """保存或更新联系人
        
        Args:
            user_data: 用户数据
            
        Returns:
            是否操作成功
        """
        from settings.config import logger
        
        wechat_id = user_data.get('wechat_id')
        account = user_data.get('account')
        
        logger.info(f"保存或更新联系人: wechat_id={wechat_id}, account={account}")
        logger.debug(f"完整用户数据: {user_data}")
        
        if not wechat_id or not account:
            logger.error(f"缺少必要字段: wechat_id={wechat_id}, account={account}")
            return False
        
        # 检查用户是否已存在
        try:
            existing_user = self.get_user_by_wechat_id(wechat_id, account)
            logger.info(f"检查用户{wechat_id}是否已存在: {bool(existing_user)}")
            
            if existing_user:
                # 更新现有用户
                logger.info(f"更新现有用户: {wechat_id}")
                result = self.update_user_by_wechat_id(wechat_id, account, user_data)
                logger.info(f"更新结果: {result}")
                return result
            else:
                # 创建新用户
                logger.info(f"创建新用户: {wechat_id}")
                user_id = self.insert_user(user_data)
                logger.info(f"创建结果: {bool(user_id)}, 新用户ID: {user_id}")
                return bool(user_id)
        except Exception as e:
            logger.error(f"保存或更新联系人出错: {e}")
            import traceback
            logger.error(traceback.format_exc())
            return False

    def get_users_by_wechat_name(self, wechat_name):
        return User.query.filter(or_(User.wechat_name == wechat_name, User.remark_name == wechat_name)).all()
